Digital image processing
1. Introduccion 🃏 ¶
1.1 Que es el Procesamiento digital de imágenes (Digital image processing)¶
El procesamiento de imágenes digitales es el conjunto de técnicas que se aplican a las imágenes digitales con el objetivo de mejorar la calidad o facilitar la búsqueda de información.
Para saber mas ver: opencv
1. Introduccion 🃏 ¶
1.1 Que es el Procesamiento digital de imágenes (Digital image processing)¶
El procesamiento de imágenes digitales es el conjunto de técnicas que se aplican a las imágenes digitales con el objetivo de mejorar la calidad o facilitar la búsqueda de información.
Para saber mas ver: opencv
Contenidos¶
import cv2 #OpenCV
import numpy as np #Vectores y matrices
from matplotlib import pyplot as plt #Gráficos
from IPython.display import Image #Plotiar imagenes de una manera ams facil
2.1 OpenCV 📗¶
Instalación
pip install opencv-python
Descripción
OpenCV (Open Source Computer Vision Library) es una biblioteca de software de visión artificial y aprendizaje automático de código abierto. OpenCV se creó para proporcionar una infraestructura común para aplicaciones de visión por computadora y para acelerar el uso de la percepción de máquinas en los productos comerciales.
La biblioteca tiene más de 2500 algoritmos optimizados, que incluyen un conjunto integral de algoritmos de visión por computadora y aprendizaje automático tanto clásicos como de última generación. Estos algoritmos se pueden usar para detectar y reconocer caras, identificar objetos, clasificar acciones humanas en videos, rastrear movimientos de cámara, rastrear objetos en movimiento, extraer modelos 3D de objetos, producir nubes de puntos 3D desde cámaras estéreo, unir imágenes para producir una alta resolución imagen de una escena completa, encuentre imágenes similares de una base de datos de imágenes, elimine los ojos rojos de las imágenes tomadas con flash, siga los movimientos de los ojos, reconozca los paisajes y establezca marcadores para superponerlos con realidad aumentada, etc.
Link
2.2 numpy 📗¶
Instalación
conda install -c anaconda -y numpy
Descripción
Numpy es una biblioteca para el lenguaje de programación Python que (entre otras cosas) brinda soporte para grandes matrices multidimensionales.
¿Por qué es eso importante? Usando NumPy, podemos expresar imágenes como matrices multidimensionales.
Representar imágenes como matrices NumPy no solo es computacional y eficiente en el uso de recursos, sino que muchas otras bibliotecas de procesamiento de imágenes y aprendizaje automático también usan representaciones de matrices NumPy. Además, al usar las funciones matemáticas de alto nivel incorporadas de NumPy, podemos realizar rápidamente análisis numéricos en una imagen.
Link
2.3 Matplotlib 📗¶
Instalación
conda install -c conda-forge -y matplotlib
Descripción
Matplotlib es una biblioteca para la generación de gráficos a partir de datos contenidos en listas o arreglos en el lenguaje de programación Python y su extensión matemática NumPy.
Por medio del comando mágico %matplotlib inline se indica que los despliegues gráficos de la biblioteca matplotlib se despliegan en el cuaderno Jupyter directamente.
Link
image1_path = './images/lenna_main.jpg'
image2_path = './images/lena.bmp'
Image(filename=image1_path)
3.3.1 Imagen a color¶
# Imagen a color.
img_color = cv2.imread(image1_path, cv2.IMREAD_COLOR)
print("La resolución de la imagen es {}".format(img_color.shape))
# Transformar imagen BGR a RGB.
img_color = cv2.cvtColor(img_color, cv2.COLOR_BGR2RGB)
plt.imshow(img_color)
plt.title('Imagen a color')
plt.axis('off');
plt.tight_layout()
# Imagen en blanco y negro.
img_gris = cv2.imread(image2_path, cv2.IMREAD_GRAYSCALE)
print("La resolución de la imagen es {}".format(img_gris.shape))
# Transformar imagen BGR a RGB.
img_gris = cv2.cvtColor(img_gris, cv2.COLOR_BGR2RGB)
plt.imshow(img_gris, cmap='gray')
plt.title('Imagen en escala de grises')
plt.axis('off');
plt.tight_layout()
4.1 Rotaciónes¶
#img_color
plt.figure(figsize=(12, 12))
#Imagen original.
plt.subplot(1,3,1)
plt.imshow(img_color)
plt.title('Imagen original')
plt.axis('off')
# Rotación vertical.
img_color_flip_vert = cv2.flip(img_color, -1)
plt.subplot(1, 3, 2)
plt.imshow(img_color_flip_vert)
plt.title('Imagen rotada verticalmente')
plt.axis('off')
plt.tight_layout()
# Rotación horizontal.
img_color_flip_horz = cv2.flip(img_color, 1)
plt.subplot(1, 3, 3)
plt.imshow(img_color_flip_horz)
plt.title('Imagen rotada horizontalmente')
plt.axis('off');
plt.tight_layout()
plt.figure(figsize=(10, 10))
img_neg = 255 - img_color
plt.subplot(2, 2, 1)
plt.imshow(img_color)
plt.title('Color')
plt.axis('off');
plt.subplot(2, 2, 2)
plt.imshow(img_neg, cmap='gray')
plt.title('Negativo de color')
plt.axis('off');
plt.tight_layout()
plt.figure(figsize=(10, 10))
img_neg = 255 - img_gris
plt.subplot(2, 2, 1)
plt.imshow(img_gris)
plt.title('Color')
plt.axis('off');
plt.subplot(2, 2, 2)
plt.imshow(img_neg, cmap='gray')
plt.title('Negativo de color')
plt.axis('off');
plt.tight_layout()
lx, ly , t= img_color.shape
plt.figure(figsize=(10, 10))
#Imagen original.
plt.subplot(1,2,1)
plt.imshow(img_color)
plt.title('Imagen original')
plt.axis('off')
# Cropping
image_mask = img_color
crop_face = image_mask[lx // 4: - lx // 4, ly // 4: - ly // 4]
plt.subplot(1, 2, 2)
plt.imshow(crop_face)
plt.title('Cropping')
plt.axis('off')
plt.tight_layout()
plt.figure(figsize=(10, 10))
plt.subplot(2, 2, 1)
plt.imshow(img_color); plt.title('Imagen original'); plt.axis('off')
img_out = cv2.edgePreservingFilter(img_color)
plt.subplot(2, 2, 2)
plt.imshow(img_out)
plt.title('Filtro promediado')
plt.axis('off');
img_out = cv2.detailEnhance(img_color);
plt.subplot(2, 2, 3)
plt.imshow(img_out)
plt.title('Realce de detalles')
plt.axis('off');
cv2.stylization(img_color,img_out)
plt.subplot(2, 2, 4)
plt.imshow(img_out)
plt.title('Imagen estilizada')
plt.axis('off');
plt.tight_layout()
plt.figure(figsize=(13, 13))
# Imagen original
plt.subplot(1, 2, 1)
plt.imshow(img_color, cmap='gray')
plt.axis('off')
plt.title('Imagen original')
t1 = 100
t2 = 200
#Bordes
img_edges = cv2.Canny(img_color, t1, t2)
plt.subplot(1, 2, 2)
plt.imshow(img_edges, cmap='gray')
plt.axis('off')
plt.title('Extracción de bordes');
plt.tight_layout()
Esta y otras funciones proporcionadas por la biblioteca nos permiten detectar los bordes o contornos de una imagen, el resultado se almacena en una imagen binaria.
- img_color: imagen de entrada.
- t1, t2: son los valores de tolerancia, nos ayudan a limitar los bordes detectados.
5.5 GaussianBlur¶
plt.figure(figsize=(13, 13))
# Imagen original
plt.subplot(1, 2, 1)
plt.imshow(img_color, cmap='gray')
plt.axis('off')
plt.title('Imagen original')
#GaussianBlur
img_edges_Blur= cv2.GaussianBlur(img_color, (13,7), 8)
plt.subplot(1, 2, 2)
plt.imshow(img_edges_Blur, cmap='gray')
plt.axis('off')
plt.title('GaussianBlur');
plt.tight_layout()
Esta función la usamos para aplicar un blur a una imagen utilizando un filtro gaussiano, los parámetros requeridos son:
- img: imagen original.
- Size(width, height): tamaño del kernel, deben ser positivos e impares.
- 8: desviación estándar en el eje X.
5.6 MedianBlur¶
plt.figure(figsize=(13, 13))
# Imagen original
plt.subplot(1, 2, 1)
plt.imshow(img_color, cmap='gray')
plt.axis('off')
plt.title('Imagen original')
#GaussianBlur
img_medianBlur= cv2.medianBlur(img_color, 5)
plt.subplot(1, 2, 2)
plt.imshow(img_edges_Blur, cmap='gray')
plt.axis('off')
plt.title('MedianBlur');
plt.tight_layout()
Aplica un blur a la imagen indicada usando el filtro de mediana, los parámetros para esta función son:
- img: imagen original o de entrada.
- 5: tamaño del kernel (ksize) debe ser mayor que 1 e impar.
5.7 Erode y Dilate¶
Estos son funciones que aplican las operaciones morfológicas de erosión y dilatación respectivamente, normalmente son usadas sobre imágenes binarias, pero también se pueden utilizar en imágenes a color como en el siguiente ejemplo:
kernel = cv2.getStructuringElement(cv2.MORPH_RECT , (7, 7));
plt.figure(figsize=(10, 10))
plt.subplot(2, 2, 1)
plt.imshow(img_color); plt.title('Imagen original'); plt.axis('off')
img_out = cv2.dilate(img_color, kernel);
plt.subplot(2, 2, 2)
plt.imshow(img_out)
plt.title('Dilatacion')
plt.axis('off');
plt.subplot(2, 2, 3)
plt.imshow(img_color); plt.title('Imagen original'); plt.axis('off')
img_out = cv2.erode(img_color, kernel);
plt.subplot(2, 2, 4)
plt.imshow(img_out)
plt.title('Erosion')
plt.axis('off');
plt.tight_layout()
plt.figure(figsize=(10, 10))
plt.subplot(2, 2, 1)
plt.imshow(img_gris); plt.title('Imagen original'); plt.axis('off')
img_out = cv2.dilate(img_gris, kernel);
plt.subplot(2, 2, 2)
plt.imshow(img_out)
plt.title('Dilatacion')
plt.axis('off');
plt.subplot(2, 2, 3)
plt.imshow(img_gris); plt.title('Imagen original'); plt.axis('off')
img_out = cv2.erode(img_gris, kernel);
plt.subplot(2, 2, 4)
plt.imshow(img_out)
plt.title('Erosion')
plt.axis('off');
plt.tight_layout()
6 Guardar una imagen¶
Una vez hemos procesado la imagen tal vez nos interese guardar en disco una copia de la imagen procesada, OpenCV nos proporciona la función cv2.imwrite() para almacenar una imagen en un archivo indicado, disponemos de distintos formatos como JPG, PNG, TIFF.
path_save = "./images/imagen.png"
#Solo es un proveso para el ejemplo de guardado
t1 = 100
t2 = 200
img_edges = cv2.Canny(img_color, t1, t2)
cv2.imwrite(path_save, img_edges)
Image(filename=path_save)
